package com.gkzf.ai.module.crm.util.packaging;

import com.alibaba.fastjson.JSON;
import com.gkzf.ai.framework.common.util.date.DateUtils;
import com.gkzf.ai.module.crm.controller.admin.creditReport.vo.admittancecondition.QueryLimitVo;
import com.gkzf.ai.module.crm.controller.admin.creditReport.vo.creditreportdetails.CreditReportDetailsSaveReqVO;
import com.gkzf.ai.module.crm.util.simpleCredit.SimpleCreditExtract;
import com.gkzf.ai.module.system.api.dict.dto.DictDataRespDTO;
import lombok.extern.slf4j.Slf4j;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.*;

import static com.gkzf.ai.module.crm.util.AnalysisJsonObjectUtils.*;
import static com.gkzf.ai.module.crm.util.simpleCredit.SimpleCreditExtract.parseAndFormatDate;

/**
 * 计算查询记录
 */
@Slf4j
public class CalculationQueryRecord {


    private final List<DictDataRespDTO> queryLimitDictDataList;

    private static final String YYYY_MM_DD = "yyyy.MM.dd";


    public CalculationQueryRecord(List<DictDataRespDTO> queryLimitDictDataList) {
        this.queryLimitDictDataList = queryLimitDictDataList;
    }

    /**
     * 获取查询记录json
     * @return
     */
    public  String extractQueryRecord( List<Map<String, String>> queryRecordMapList,CreditReportDetailsSaveReqVO detailsDO){
        Map<String,Integer> queryLimitMaxCount = new HashMap<>();
        List<QueryLimitVo> queryLimitVoList = new ArrayList<>();
        List<String> queryRecordList = new ArrayList<>();
        detailsDO.setQueryRecordCollect(JSON.toJSONString(queryRecordMapList));
        queryRecordMapList.forEach(item ->{

            boolean bool = Boolean.TRUE;
            /*
                查询原因是贷后管理不记录 如果状态是贷后管理直接返回不计算
             */
            for (Map.Entry<String, String> jsonObjectNext : item.entrySet()) {
                if (Objects.equals(jsonObjectNext.getKey(), QUERY_CAUSE) && Objects.equals(jsonObjectNext.getValue(), POST_LOAN_MANAGEMENT)) {
                    bool = Boolean.FALSE;
                }
            }
            /*
               计算除贷后管理类型
             */
            if (bool) {
                int queryLimitWay = 0;
                /*
                    判断是机构 还是 本人查询的
                 */
                for (Map.Entry<String, String> jsonObjectNext : item.entrySet()) {

                    if (Objects.equals(jsonObjectNext.getKey(), QUERY_INSTITUTION)) {
                        if (jsonObjectNext.getValue().contains(SELF)) {
                            queryLimitWay = 2;
                        } else {
                            queryLimitWay = 1;
                        }
                    }
                }
                /*
                   计算 查询查询明细
                 */
                for (Map.Entry<String, String> jsonObjectNext : item.entrySet()) {
                    if (Objects.equals(jsonObjectNext.getKey(), QUERY_DATE)) {
                        queryRecordList.add(jsonObjectNext.getValue());
                        getQueryLimitVo(queryLimitMaxCount, jsonObjectNext.getValue(), queryLimitWay);
                    }
                }

            }
               /*
                计算细分类型
               */
                int querySubdivisionLimitWay = 0;
                for (Map.Entry<String, String> jsonObjectNext : item.entrySet()) {
                    if (Objects.equals(jsonObjectNext.getKey(), QUERY_CAUSE)) {
                        querySubdivisionLimitWay = switch (jsonObjectNext.getValue()) {
                            case "贷款审批" -> 3;
                            case "信用卡审批" -> 4;
                            case "资信审查" -> 5;
                            case "担保资格审查" -> 6;
                            case "法人代表、负责人、高管等资信审查" -> 7;
                            default -> 0;
                        };
                    }
                }
                for (Map.Entry<String, String> jsonObjectNext : item.entrySet()) {
                    if (Objects.equals(jsonObjectNext.getKey(), QUERY_DATE) && querySubdivisionLimitWay != 0) {
                        getQueryLimitVo(queryLimitMaxCount, jsonObjectNext.getValue(), querySubdivisionLimitWay);
                    }
                }
        });

        /**
         * 统计查询记录 不同时间维度 统计
         */
        Iterator<Map.Entry<String, Integer>> iterator = queryLimitMaxCount.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> next = iterator.next();
            String[] queryLimitWay = next.getKey().split(":");
            Integer integerValue = queryLimitMaxCount.get(next.getKey());
            int integer = Optional.ofNullable(integerValue).orElse(0);
            QueryLimitVo queryLimitVo = new QueryLimitVo();
            queryLimitVo.setQueryLimitWay(Integer.parseInt(queryLimitWay[1]));
            queryLimitVo.setQueryLimitMonths(Integer.valueOf(queryLimitWay[0]));

            queryLimitVo.setQueryLimitMaxCount(integer);
            queryLimitVoList.add(queryLimitVo);
        }

        detailsDO.setMostRecentQueryTime(getQueryMaxDateTime(queryRecordList));
        return JSON.toJSONString(queryLimitVoList);
    }



    /**
     * 还款记录时间规则
     *  征信报告记录天数 往前推n个月 最后一个月天数加1
     *                      比如 2025-04-30 推 3个月 2025-01-31
     *                      比如 2025-07-31 推一个月 2025-06-30
     *                      比如 2025-07-30 推一个月 2025-06-30 当往前推的天数没有加1的天数 则天数不变，否则加1
     * @param queryLimitMaxCount 存储的map
     * @param dateStr 数据时间
     * @param queryLimitWay 查询类型 1本人 2机构
     */
    private  void getQueryLimitVo(Map<String,Integer> queryLimitMaxCount,String dateStr,Integer queryLimitWay){
        queryLimitDictDataList.forEach(item ->{

            // 不计算等于0的
            if (Objects.equals(item.getValue(),"0")){
                return;
            }
            Integer queryLimitMaxNumber = Integer.valueOf(item.getValue());
            // 征信报告打印时间
            LocalDate entDate = LocalDate.now();
            // 往后推的月数
            LocalDate startDate = entDate.minusMonths(queryLimitMaxNumber);
            // 获取当前月的最后一天
            LocalDate lastDayOfMonth = startDate.with(TemporalAdjusters.lastDayOfMonth());
            // 如果今天是本月最后一天，不加1天
            if (!startDate.isEqual(lastDayOfMonth)) {
                startDate = startDate.plusDays(1); // 加一天，因为不是是月底
            }

            // 判断时间是否在范围内
            LocalDate dateLocalDate =  parseAndFormatDate(dateStr);
            if(Objects.nonNull(dateLocalDate)) {
                boolean dateBetween = DateUtils.isDateBetween(dateLocalDate, startDate, entDate);
                // 获取key中的值
                Integer defaultValue = queryLimitMaxCount.get(queryLimitMaxNumber + ":" + queryLimitWay);
                int number = Objects.isNull(defaultValue) ? 0 : defaultValue;
                if (dateBetween) {
                    queryLimitMaxCount.put(queryLimitMaxNumber + ":" + queryLimitWay, number + 1);
                } else {
                    queryLimitMaxCount.put(queryLimitMaxNumber + ":" + queryLimitWay, number);
                }
            }
        });
    }

    /**
     *  对比出最大 查询时间
     */
    public static String getQueryMaxDateTime(List<String> timeList){
        // 定义时间格式化器
        if (timeList.isEmpty()){
           return "";
        }
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(YYYY_MM_DD);
        // 使用 stream 将时间字符串转换为 LocalDateTime，并找出最大时间
        LocalDate maxTime = timeList.stream()
                .map(SimpleCreditExtract::parseAndFormatDate)  // 将字符串转换为 LocalDateTime
                .filter(Objects::nonNull)
                .max(LocalDate::compareTo)  // 比较最大时间
                .orElseThrow(() -> new IllegalArgumentException("List is empty"));
        return maxTime.format(formatter);
    }

}
